!ls

augmented.keras  model_best.keras   residual.keras		    test
batch.keras	 model.png	    res-net.keras		    train
model_best.h5	 regularized.keras  res-net-trainable-layers.keras  validation

%cd ../

/content/drive/MyDrive/data

import os
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.applications import VGG16, ResNet50, InceptionV3
import pandas as pd
from sklearn.metrics import confusion_matrix, classification_report

# Check for GPU availability
print("GPU Available: ", tf.config.list_physical_devices('GPU'))
print("TensorFlow version: ", tf.__version__)

# Set random seeds for reproducibility
np.random.seed(42)
tf.random.set_seed(42)

GPU Available:  [PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
TensorFlow version:  2.18.0

# Define the base directory
base_dir = "split_clash"

# Display the directory structure
print("Dataset structure:")
for split in ['train', 'validation', 'test']:
    split_dir = os.path.join(base_dir, split)
    print(f"\n{split} directory:")
    classes = os.listdir(split_dir)
    print(f"Classes: {classes}")

    for cls in classes:
        class_dir = os.path.join(split_dir, cls)
        num_images = len(os.listdir(class_dir))
        print(f"  - {cls}: {num_images} images")

# Count total images
total_images = 0
for split in ['train', 'validation', 'test']:
    split_dir = os.path.join(base_dir, split)
    for cls in os.listdir(split_dir):
        class_dir = os.path.join(split_dir, cls)
        total_images += len(os.listdir(class_dir))

print(f"\nTotal images in dataset: {total_images}")

Dataset structure:

train directory:
Classes: ['th_13', 'th_14', 'th_11', 'th_17', 'th_15', 'th_12', 'th_16', 'th_10']
  - th_13: 90 images
  - th_14: 90 images
  - th_11: 90 images
  - th_17: 93 images
  - th_15: 98 images
  - th_12: 90 images
  - th_16: 81 images
  - th_10: 90 images

validation directory:
Classes: ['th_13', 'th_15', 'th_14', 'th_12', 'th_17', 'th_10', 'th_11', 'th_16']
  - th_13: 20 images
  - th_15: 22 images
  - th_14: 20 images
  - th_12: 20 images
  - th_17: 20 images
  - th_10: 20 images
  - th_11: 20 images
  - th_16: 18 images

test directory:
Classes: ['th_16', 'th_12', 'th_15', 'th_14', 'th_17', 'th_11', 'th_13', 'th_10']
  - th_16: 18 images
  - th_12: 20 images
  - th_15: 22 images
  - th_14: 20 images
  - th_17: 21 images
  - th_11: 20 images
  - th_13: 20 images
  - th_10: 20 images

Total images in dataset: 1043

import matplotlib.pyplot as plt
import random
from tensorflow.keras.preprocessing.image import load_img, img_to_array

# Function to load and display sample images from each class
def display_sample_images(base_dir, split='train', num_samples=2):
    split_dir = os.path.join(base_dir, split)
    classes = sorted(os.listdir(split_dir))

    # Set up the plot grid
    fig, axes = plt.subplots(len(classes), num_samples, figsize=(12, 3*len(classes)))

    for i, cls in enumerate(classes):
        class_dir = os.path.join(split_dir, cls)
        image_files = os.listdir(class_dir)

        # Select random samples
        samples = random.sample(image_files, min(num_samples, len(image_files)))

        for j, sample in enumerate(samples):
            img_path = os.path.join(class_dir, sample)
            img = load_img(img_path)

            # Get image dimensions
            width, height = img.size

            # Display image
            axes[i, j].imshow(img)
            axes[i, j].set_title(f"{cls} ({width}x{height})")
            axes[i, j].axis('off')

    plt.tight_layout()
    plt.show()

    # Return a sample image to determine typical dimensions
    sample_img_path = os.path.join(split_dir, classes[0], os.listdir(os.path.join(split_dir, classes[0]))[0])
    sample_img = load_img(sample_img_path)
    print(f"Sample image dimensions: {sample_img.size}")
    return sample_img.size

# Visualize samples from training set
img_size = display_sample_images(base_dir, 'train', 3)

Sample image dimensions: (2532, 1170)

# Analyze class distribution
def analyze_class_distribution(base_dir):
    # Initialize dictionaries to store counts
    distribution = {split: {} for split in ['train', 'validation', 'test']}

    # Count images per class in each split
    for split in ['train', 'validation', 'test']:
        split_dir = os.path.join(base_dir, split)
        classes = sorted(os.listdir(split_dir))

        for cls in classes:
            class_dir = os.path.join(split_dir, cls)
            distribution[split][cls] = len(os.listdir(class_dir))

    # Create a DataFrame for easier visualization
    df_dist = pd.DataFrame(distribution)

    # Calculate total per class
    df_dist['total'] = df_dist.sum(axis=1)

    # Calculate percentage per split
    for split in ['train', 'validation', 'test']:
        df_dist[f'{split}_pct'] = (df_dist[split] / df_dist['total'] * 100).round(2)

    # Display table
    print("Class Distribution:")
    print(df_dist)

    # Plot distribution
    plt.figure(figsize=(12, 6))

    # Plot count per class per split
    ax1 = plt.subplot(1, 2, 1)
    df_dist[['train', 'validation', 'test']].plot(kind='bar', ax=ax1)
    plt.title('Images per Class')
    plt.ylabel('Number of Images')
    plt.xlabel('Town Hall Level')
    plt.legend(title='Split')

    # Plot total distribution
    ax2 = plt.subplot(1, 2, 2)
    df_dist['total'].plot(kind='bar', ax=ax2, color='teal')
    plt.title('Total Images per Class')
    plt.ylabel('Number of Images')
    plt.xlabel('Town Hall Level')

    plt.tight_layout()
    plt.show()

    return df_dist

# Run the analysis
class_dist = analyze_class_distribution(base_dir)

Class Distribution:
       train  validation  test  total  train_pct  validation_pct  test_pct
th_10     90          20    20    130      69.23           15.38     15.38
th_11     90          20    20    130      69.23           15.38     15.38
th_12     90          20    20    130      69.23           15.38     15.38
th_13     90          20    20    130      69.23           15.38     15.38
th_14     90          20    20    130      69.23           15.38     15.38
th_15     98          22    22    142      69.01           15.49     15.49
th_16     81          18    18    117      69.23           15.38     15.38
th_17     93          20    21    134      69.40           14.93     15.67

# After analyzing the sample images, define appropriate dimensions
# Note: We'll finalize this once we see the actual image dimensions

def determine_optimal_dimensions(base_dir):
    """
    Analyze a sample of images to determine optimal dimensions for preprocessing
    """
    dimensions = []

    # Sample some images from each class in the training set
    train_dir = os.path.join(base_dir, 'train')
    classes = os.listdir(train_dir)

    for cls in classes:
        class_dir = os.path.join(train_dir, cls)
        images = os.listdir(class_dir)[:5]  # Sample up to 5 images per class

        for img_name in images:
            img_path = os.path.join(class_dir, img_name)
            img = load_img(img_path)
            dimensions.append(img.size)

    # Calculate statistics
    widths = [d[0] for d in dimensions]
    heights = [d[1] for d in dimensions]

    print(f"Width - Min: {min(widths)}, Max: {max(widths)}, Median: {np.median(widths)}")
    print(f"Height - Min: {min(heights)}, Max: {max(heights)}, Median: {np.median(heights)}")

    # Plot dimension distribution
    plt.figure(figsize=(12, 5))

    plt.subplot(1, 2, 1)
    plt.hist(widths, bins=10)
    plt.title('Width Distribution')
    plt.xlabel('Width (pixels)')

    plt.subplot(1, 2, 2)
    plt.hist(heights, bins=10)
    plt.title('Height Distribution')
    plt.xlabel('Height (pixels)')

    plt.tight_layout()
    plt.show()

    # Suggest dimensions based on the median (rounded to nearest multiple of 32)
    median_width = np.median(widths)
    median_height = np.median(heights)

    suggested_width = int(np.ceil(median_width / 32) * 32)
    suggested_height = int(np.ceil(median_height / 32) * 32)

    # If too large, cap at reasonable size
    max_dim = 224  # Standard input size for many pre-trained models

    if suggested_width > max_dim or suggested_height > max_dim:
        aspect_ratio = median_width / median_height
        if aspect_ratio > 1:
            suggested_width = max_dim
            suggested_height = int(max_dim / aspect_ratio)
        else:
            suggested_height = max_dim
            suggested_width = int(max_dim * aspect_ratio)

    print(f"Suggested dimensions: {suggested_width}x{suggested_height}")
    return suggested_width, suggested_height

# Run the analysis to determine optimal dimensions
target_width, target_height = determine_optimal_dimensions(base_dir)

# We'll use these dimensions throughout our project
IMG_SIZE = (target_width, target_height)
print(f"Selected image dimensions: {IMG_SIZE}")

Width - Min: 2436, Max: 2622, Median: 2532.0
Height - Min: 1125, Max: 1206, Median: 1170.0

Suggested dimensions: 224x103
Selected image dimensions: (224, 103)

# Define image dimensions and batch size
IMG_WIDTH, IMG_HEIGHT = 224, 103
BATCH_SIZE = 32

# Define data generators
def create_data_generators(base_dir):
    # Create basic data generators (no augmentation yet)
    train_datagen = ImageDataGenerator(
        rescale=1./255
    )

    validation_datagen = ImageDataGenerator(
        rescale=1./255
    )

    test_datagen = ImageDataGenerator(
        rescale=1./255
    )

    # Create generators for each split
    train_generator = train_datagen.flow_from_directory(
        os.path.join(base_dir, 'train'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=True
    )

    validation_generator = validation_datagen.flow_from_directory(
        os.path.join(base_dir, 'validation'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=False
    )

    test_generator = test_datagen.flow_from_directory(
        os.path.join(base_dir, 'test'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=False
    )

    # Get class indices to understand the mapping
    class_indices = train_generator.class_indices
    print("Class indices:", class_indices)

    # Number of classes
    num_classes = len(class_indices)
    print(f"Number of classes: {num_classes}")

    return train_generator, validation_generator, test_generator, num_classes

# Create generators
base_dir = "split_clash"  # Using the correct directory name
train_generator, validation_generator, test_generator, num_classes = create_data_generators(base_dir)

# Calculate steps per epoch
steps_per_epoch = train_generator.samples // BATCH_SIZE
validation_steps = validation_generator.samples // BATCH_SIZE + 1  # Add 1 to ensure all samples are evaluated
print(f"Steps per epoch: {steps_per_epoch}")
print(f"Validation steps: {validation_steps}")

# Extract class names for later use
class_names = list(train_generator.class_indices.keys())
print(f"Class names: {class_names}")

Found 721 images belonging to 8 classes.
Found 160 images belonging to 8 classes.
Found 161 images belonging to 8 classes.
Class indices: {'th_10': 0, 'th_11': 1, 'th_12': 2, 'th_13': 3, 'th_14': 4, 'th_15': 5, 'th_16': 6, 'th_17': 7}
Number of classes: 8
Steps per epoch: 22
Validation steps: 6
Class names: ['th_10', 'th_11', 'th_12', 'th_13', 'th_14', 'th_15', 'th_16', 'th_17']

def create_baseline_model(input_shape, num_classes):
    """
    Create a baseline CNN model for the Town Hall classification task
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),

        # Second convolutional block
        layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Third convolutional block
        layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Fourth convolutional block
        layers.Conv2D(256, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dense(num_classes, activation='softmax')
    ])

    # Compile the model
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# Create the baseline model
input_shape = (IMG_HEIGHT, IMG_WIDTH, 3)  # Height, Width, Channels
baseline_model = create_baseline_model(input_shape, num_classes)

# Print model summary
baseline_model.summary()

# Visualize the model architecture (optional)
from tensorflow.keras.utils import plot_model
plot_model(baseline_model, to_file='baseline_model.png', show_shapes=True, show_layer_names=True)

/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Model: "sequential"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D)                 │ (None, 103, 224, 32)   │           896 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d (MaxPooling2D)    │ (None, 51, 112, 32)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_1 (Conv2D)               │ (None, 51, 112, 64)    │        18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_1 (MaxPooling2D)  │ (None, 25, 56, 64)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_2 (Conv2D)               │ (None, 25, 56, 128)    │        73,856 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_2 (MaxPooling2D)  │ (None, 12, 28, 128)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_3 (Conv2D)               │ (None, 12, 28, 256)    │       295,168 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_3 (MaxPooling2D)  │ (None, 6, 14, 256)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten (Flatten)               │ (None, 21504)          │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense (Dense)                   │ (None, 512)            │    11,010,560 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_1 (Dense)                 │ (None, 8)              │         4,104 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 11,403,080 (43.50 MB)

 Trainable params: 11,403,080 (43.50 MB)

 Non-trainable params: 0 (0.00 B)

# Create a directory for model checkpoints
checkpoint_dir = 'model_checkpoints'
os.makedirs(checkpoint_dir, exist_ok=True)

# Setup callbacks
def setup_callbacks(model_name):
    early_stopping = EarlyStopping(
        monitor='val_accuracy',
        patience=10,
        restore_best_weights=True,
        verbose=1
    )

    checkpoint_path = os.path.join(checkpoint_dir, f"{model_name}_best.h5")
    model_checkpoint = ModelCheckpoint(
        checkpoint_path,
        monitor='val_accuracy',
        save_best_only=True,
        mode='max',
        verbose=1
    )

    return [early_stopping, model_checkpoint]

# Function to plot learning curves
def plot_learning_curves(history, model_name):
    plt.figure(figsize=(12, 5))

    # Plot training & validation accuracy
    plt.subplot(1, 2, 1)
    plt.plot(history.history['accuracy'])
    plt.plot(history.history['val_accuracy'])
    plt.title(f'{model_name} - Accuracy')
    plt.ylabel('Accuracy')
    plt.xlabel('Epoch')
    plt.legend(['Train', 'Validation'], loc='lower right')

    # Plot training & validation loss
    plt.subplot(1, 2, 2)
    plt.plot(history.history['loss'])
    plt.plot(history.history['val_loss'])
    plt.title(f'{model_name} - Loss')
    plt.ylabel('Loss')
    plt.xlabel('Epoch')
    plt.legend(['Train', 'Validation'], loc='upper right')

    plt.tight_layout()
    plt.savefig(f'{model_name}_learning_curves.png')
    plt.show()

# Function to evaluate model on test set
def evaluate_model(model, test_generator):
    # Evaluate on test set
    test_loss, test_acc = model.evaluate(test_generator)
    print(f"Test accuracy: {test_acc:.4f}")
    print(f"Test loss: {test_loss:.4f}")

    # Get predictions
    test_generator.reset()
    y_pred = model.predict(test_generator)
    y_pred_classes = np.argmax(y_pred, axis=1)

    # Get true labels
    y_true = test_generator.classes

    # Generate confusion matrix
    cm = confusion_matrix(y_true, y_pred_classes)

    # Plot confusion matrix
    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
                xticklabels=class_names,
                yticklabels=class_names)
    plt.xlabel('Predicted')
    plt.ylabel('True')
    plt.title('Confusion Matrix')
    plt.tight_layout()
    plt.savefig('confusion_matrix.png')
    plt.show()

    # Print classification report
    report = classification_report(y_true, y_pred_classes, target_names=class_names)
    print("Classification Report:")
    print(report)

    return test_acc, y_pred_classes, y_true

# Train the baseline model
def train_model(model, model_name):
    callbacks = setup_callbacks(model_name)

    history = model.fit(
        train_generator,
        steps_per_epoch=steps_per_epoch,
        epochs=50,  # Start with a high number, early stopping will prevent overfitting
        validation_data=validation_generator,
        validation_steps=validation_steps,
        callbacks=callbacks,
        verbose=1
    )

    # Plot learning curves
    plot_learning_curves(history, model_name)

    # Evaluate on test set
    test_acc, y_pred_classes, y_true = evaluate_model(model, test_generator)

    return history, test_acc, y_pred_classes, y_true

# Train the baseline model
baseline_history, baseline_test_acc, baseline_y_pred, baseline_y_true = train_model(baseline_model, 'baseline')

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.
  self._warn_if_super_not_called()

Epoch 1/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10s/step - accuracy: 0.1644 - loss: 2.1276
Epoch 1: val_accuracy improved from -inf to 0.41250, saving model to model_checkpoints/baseline_best.h5

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 298s 13s/step - accuracy: 0.1667 - loss: 2.1222 - val_accuracy: 0.4125 - val_loss: 1.5226
Epoch 2/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.4062 - loss: 1.4679
Epoch 2: val_accuracy improved from 0.41250 to 0.46875, saving model to model_checkpoints/baseline_best.h5

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 448ms/step - accuracy: 0.4062 - loss: 1.4679 - val_accuracy: 0.4688 - val_loss: 1.3766
Epoch 3/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.4987 - loss: 1.2430
Epoch 3: val_accuracy improved from 0.46875 to 0.51250, saving model to model_checkpoints/baseline_best.h5

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 52s 2s/step - accuracy: 0.5009 - loss: 1.2375 - val_accuracy: 0.5125 - val_loss: 1.1320
Epoch 4/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.3750 - loss: 1.2923
Epoch 4: val_accuracy improved from 0.51250 to 0.59375, saving model to model_checkpoints/baseline_best.h5

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 10s 471ms/step - accuracy: 0.3750 - loss: 1.2923 - val_accuracy: 0.5938 - val_loss: 0.8631
Epoch 5/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.6580 - loss: 0.8595
Epoch 5: val_accuracy improved from 0.59375 to 0.81250, saving model to model_checkpoints/baseline_best.h5

# Create different CNN architectures to experiment with
def create_model_v2(input_shape, num_classes):
    """
    Second version with more filters
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(64, (3, 3), activation='relu', padding='same', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),

        # Second convolutional block
        layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Third convolutional block
        layers.Conv2D(256, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Fourth convolutional block
        layers.Conv2D(512, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(1024, activation='relu'),
        layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

def create_model_v3(input_shape, num_classes):
    """
    Third version with deeper architecture (more layers)
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=input_shape),
        layers.Conv2D(32, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Second convolutional block
        layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
        layers.Conv2D(64, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Third convolutional block
        layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
        layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Fourth convolutional block
        layers.Conv2D(256, (3, 3), activation='relu', padding='same'),
        layers.Conv2D(256, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

def create_model_v4(input_shape, num_classes):
    """
    Fourth version with different filter sizes
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(32, (5, 5), activation='relu', padding='same', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),

        # Second convolutional block
        layers.Conv2D(64, (5, 5), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Third convolutional block
        layers.Conv2D(128, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Fourth convolutional block
        layers.Conv2D(256, (3, 3), activation='relu', padding='same'),
        layers.MaxPooling2D((2, 2)),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# Dictionary to store results
model_results = {
    'baseline': {
        'val_accuracy': None,
        'test_accuracy': baseline_test_acc,
        'description': 'Standard CNN with 4 conv blocks, filter sizes: 32-64-128-256'
    }
}

# Train and evaluate additional models
models_to_try = [
    ('model_v2', create_model_v2, 'More filters: 64-128-256-512, dense: 1024'),
    ('model_v3', create_model_v3, 'Deeper architecture with double conv layers per block'),
    ('model_v4', create_model_v4, 'Different filter sizes: 5x5 in early layers, 3x3 in later layers')
]

# Function to train all model variants
def train_all_model_variants():
    for model_name, model_func, description in models_to_try:
        print(f"\n{'='*50}")
        print(f"Training {model_name}: {description}")
        print(f"{'='*50}")

        # Create the model
        model = model_func(input_shape, num_classes)
        model.summary()

        # Train and evaluate
        history, test_acc, _, _ = train_model(model, model_name)

        # Store results
        val_acc = max(history.history['val_accuracy'])
        model_results[model_name] = {
            'val_accuracy': val_acc,
            'test_accuracy': test_acc,
            'description': description
        }

    # Print comparison table
    print("\n\nModel Comparison:")
    print(f"{'Model':<12} {'Val Acc':<10} {'Test Acc':<10} {'Description'}")
    print(f"{'-'*80}")

    for model_name, results in model_results.items():
        val_acc = results['val_accuracy']
        test_acc = results['test_accuracy']
        desc = results['description']

        val_acc_str = f"{val_acc:.4f}" if val_acc is not None else "N/A"
        test_acc_str = f"{test_acc:.4f}" if test_acc is not None else "N/A"

        print(f"{model_name:<12} {val_acc_str:<10} {test_acc_str:<10} {desc}")

    # Find best model
    best_model = max(model_results.items(), key=lambda x: x[1]['test_accuracy'])
    print(f"\nBest model: {best_model[0]} with test accuracy: {best_model[1]['test_accuracy']:.4f}")

    return best_model[0]

# Run the model training experiment - just try model_v3 (deeper architecture)
print("\n{'='*50}")
print(f"Training model_v3: Deeper architecture with double conv layers per block")
print(f"{'='*50}")

# Create the model
model_v3 = create_model_v3(input_shape, num_classes)
model_v3.summary()

# Train and evaluate
history_v3, test_acc_v3, _, _ = train_model(model_v3, 'model_v3')

# Store results
val_acc_v3 = max(history_v3.history['val_accuracy'])
model_results['model_v3'] = {
    'val_accuracy': val_acc_v3,
    'test_accuracy': test_acc_v3,
    'description': 'Deeper architecture with double conv layers per block'
}

# Print comparison table
print("\n\nModel Comparison:")
print(f"{'Model':<12} {'Val Acc':<10} {'Test Acc':<10} {'Description'}")
print(f"{'-'*80}")

for model_name, results in model_results.items():
    val_acc = results['val_accuracy']
    test_acc = results['test_accuracy']
    desc = results['description']

    val_acc_str = f"{val_acc:.4f}" if val_acc is not None else "N/A"
    test_acc_str = f"{test_acc:.4f}" if test_acc is not None else "N/A"

    print(f"{model_name:<12} {val_acc_str:<10} {test_acc_str:<10} {desc}")

# Determine if model_v3 improves over baseline
if test_acc_v3 > baseline_test_acc:
    print(f"\nModel v3 improves over baseline by {(test_acc_v3 - baseline_test_acc)*100:.2f}%")
    best_model_name = 'model_v3'
else:
    print(f"\nModel v3 does not improve over baseline. Staying with baseline model.")
    best_model_name = 'baseline'

{'='*50}
Training model_v3: Deeper architecture with double conv layers per block
==================================================

/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Model: "sequential_1"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d_4 (Conv2D)               │ (None, 103, 224, 32)   │           896 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_5 (Conv2D)               │ (None, 103, 224, 32)   │         9,248 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_4 (MaxPooling2D)  │ (None, 51, 112, 32)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_6 (Conv2D)               │ (None, 51, 112, 64)    │        18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_7 (Conv2D)               │ (None, 51, 112, 64)    │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_5 (MaxPooling2D)  │ (None, 25, 56, 64)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_8 (Conv2D)               │ (None, 25, 56, 128)    │        73,856 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_9 (Conv2D)               │ (None, 25, 56, 128)    │       147,584 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_6 (MaxPooling2D)  │ (None, 12, 28, 128)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_10 (Conv2D)              │ (None, 12, 28, 256)    │       295,168 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_11 (Conv2D)              │ (None, 12, 28, 256)    │       590,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_7 (MaxPooling2D)  │ (None, 6, 14, 256)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten_1 (Flatten)             │ (None, 21504)          │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_2 (Dense)                 │ (None, 512)            │    11,010,560 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_3 (Dense)                 │ (None, 8)              │         4,104 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 12,186,920 (46.49 MB)

 Trainable params: 12,186,920 (46.49 MB)

 Non-trainable params: 0 (0.00 B)

Epoch 1/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.1235 - loss: 2.1261
Epoch 1: val_accuracy improved from -inf to 0.12500, saving model to model_checkpoints/model_v3_best.h5

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 57s 2s/step - accuracy: 0.1234 - loss: 2.1249 - val_accuracy: 0.1250 - val_loss: 2.0792
Epoch 2/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 16ms/step - accuracy: 0.0938 - loss: 2.0802
Epoch 2: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 428ms/step - accuracy: 0.0938 - loss: 2.0802 - val_accuracy: 0.1250 - val_loss: 2.0792
Epoch 3/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.1150 - loss: 2.0801
Epoch 3: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 48s 2s/step - accuracy: 0.1148 - loss: 2.0801 - val_accuracy: 0.1250 - val_loss: 2.0786
Epoch 4/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 14ms/step - accuracy: 0.0312 - loss: 2.0800
Epoch 4: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 442ms/step - accuracy: 0.0312 - loss: 2.0800 - val_accuracy: 0.1250 - val_loss: 2.0791
Epoch 5/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.1236 - loss: 2.0786
Epoch 5: val_accuracy improved from 0.12500 to 0.13750, saving model to model_checkpoints/model_v3_best.h5

# Define various data augmentation configurations to experiment with
def create_augmented_generator(base_dir, aug_config, name):
    """
    Create a data generator with specific augmentation settings
    """
    # Create training data generator with augmentations
    train_datagen = ImageDataGenerator(
        rescale=1./255,
        **aug_config
    )

    # Validation and test generators remain the same (no augmentation)
    validation_datagen = ImageDataGenerator(rescale=1./255)
    test_datagen = ImageDataGenerator(rescale=1./255)

    # Create generators
    train_generator = train_datagen.flow_from_directory(
        os.path.join(base_dir, 'train'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=True
    )

    validation_generator = validation_datagen.flow_from_directory(
        os.path.join(base_dir, 'validation'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=False
    )

    test_generator = test_datagen.flow_from_directory(
        os.path.join(base_dir, 'test'),
        target_size=(IMG_HEIGHT, IMG_WIDTH),
        batch_size=BATCH_SIZE,
        class_mode='categorical',
        shuffle=False
    )

    print(f"Created augmented generator: {name}")
    return train_generator, validation_generator, test_generator

# Define augmentation configurations to test
augmentation_configs = {
    'basic': {
        'rotation_range': 10,
        'width_shift_range': 0.1,
        'height_shift_range': 0.1,
        'zoom_range': 0.1,
        'horizontal_flip': True
    },
    'moderate': {
        'rotation_range': 20,
        'width_shift_range': 0.2,
        'height_shift_range': 0.2,
        'zoom_range': 0.2,
        'horizontal_flip': True,
        'vertical_flip': False,
        'brightness_range': [0.8, 1.2]
    },
    'aggressive': {
        'rotation_range': 30,
        'width_shift_range': 0.3,
        'height_shift_range': 0.3,
        'zoom_range': 0.3,
        'horizontal_flip': True,
        'vertical_flip': True,
        'brightness_range': [0.7, 1.3],
        'shear_range': 0.2,
        'fill_mode': 'nearest'
    }
}

# Function to train with different augmentation configurations
def train_with_augmentations(model_func, model_name, base_model_results):
    """
    Train the model with different augmentation configurations
    """
    augmentation_results = {
        'no_aug': base_model_results  # Include baseline without augmentation for comparison
    }

    for aug_name, aug_config in augmentation_configs.items():
        print(f"\n{'='*50}")
        print(f"Training with {aug_name} augmentation:")
        print(f"Config: {aug_config}")
        print(f"{'='*50}")

        # Create data generators with this augmentation
        aug_train_gen, aug_val_gen, aug_test_gen = create_augmented_generator(
            base_dir, aug_config, aug_name
        )

        # Create a fresh model
        model = model_func(input_shape, num_classes)

        # Setup callbacks
        callbacks = setup_callbacks(f"{model_name}_{aug_name}")

        # Train model
        history = model.fit(
            aug_train_gen,
            steps_per_epoch=steps_per_epoch,
            epochs=50,  # Early stopping will prevent overfitting
            validation_data=aug_val_gen,
            validation_steps=validation_steps,
            callbacks=callbacks,
            verbose=1
        )

        # Plot learning curves
        plot_learning_curves(history, f"{model_name}_{aug_name}")

        # Evaluate on test set
        test_loss, test_acc = model.evaluate(aug_test_gen)
        print(f"Test accuracy with {aug_name} augmentation: {test_acc:.4f}")

        # Store results
        val_acc = max(history.history['val_accuracy'])
        augmentation_results[aug_name] = {
            'val_accuracy': val_acc,
            'test_accuracy': test_acc,
            'config': aug_config
        }

    # Create a comparison table
    print("\n\nAugmentation Comparison for", model_name)
    print(f"{'Config':<12} {'Val Acc':<10} {'Test Acc':<10}")
    print(f"{'-'*40}")

    for aug_name, results in augmentation_results.items():
        val_acc = results['val_accuracy']
        test_acc = results['test_accuracy']
        print(f"{aug_name:<12} {val_acc:.4f} {test_acc:.4f}")

    # Find best augmentation
    best_aug = max(augmentation_results.items(), key=lambda x: x[1]['test_accuracy'])
    print(f"\nBest augmentation: {best_aug[0]} with test accuracy: {best_aug[1]['test_accuracy']:.4f}")

    # Compare with base model
    base_acc = base_model_results['test_accuracy']
    improvement = (best_aug[1]['test_accuracy'] - base_acc) * 100
    print(f"Improvement over base model: {improvement:.2f}%")

    return best_aug[0], best_aug[1]['test_accuracy'], augmentation_results

# Function to visualize augmented samples
def visualize_augmentations(aug_config):
    # Set up a figure to display original and augmented images
    plt.figure(figsize=(12, 6))

    # Create an augmentation generator for a single image
    datagen = ImageDataGenerator(**aug_config)

    # Get a sample image from the training set
    train_dir = os.path.join(base_dir, 'train')
    classes = os.listdir(train_dir)
    sample_class = classes[0]  # Use first class
    class_dir = os.path.join(train_dir, sample_class)
    sample_img_name = os.listdir(class_dir)[0]  # Use first image
    sample_img_path = os.path.join(class_dir, sample_img_name)

    # Load the image
    img = load_img(sample_img_path, target_size=(IMG_HEIGHT, IMG_WIDTH))
    x = img_to_array(img)
    x = x.reshape((1,) + x.shape)

    # Display original image
    plt.subplot(1, 5, 1)
    plt.imshow(img)
    plt.title('Original')
    plt.axis('off')

    # Generate and display augmented images
    i = 0
    for batch in datagen.flow(x, batch_size=1):
        plt.subplot(1, 5, i+2)
        plt.imshow(batch[0].astype('uint8'))
        plt.title(f'Augmented {i+1}')
        plt.axis('off')
        i += 1
        if i >= 4:  # Show 4 augmented examples
            break

    plt.tight_layout()
    plt.suptitle(f"Augmentation Examples")
    plt.show()

# This function will be called after we determine the best architecture
def run_data_augmentation(best_model_func, best_model_name, base_model_results):
    """
    Run data augmentation experiments with the best model architecture
    """
    # First, visualize the different augmentation strategies
    for aug_name, aug_config in augmentation_configs.items():
        print(f"\nVisualizing {aug_name} augmentation:")
        visualize_augmentations(aug_config)

    # Then train with each augmentation strategy
    best_aug, best_aug_acc, aug_results = train_with_augmentations(
        best_model_func, best_model_name, base_model_results
    )

    return best_aug, best_aug_acc, aug_results

# This will be used after determining the best model architecture
run_data_augmentation(create_baseline_model, 'baseline', model_results['baseline'])

Visualizing basic augmentation:

Visualizing moderate augmentation:

Visualizing aggressive augmentation:

==================================================
Training with basic augmentation:
Config: {'rotation_range': 10, 'width_shift_range': 0.1, 'height_shift_range': 0.1, 'zoom_range': 0.1, 'horizontal_flip': True}
==================================================
Found 721 images belonging to 8 classes.
Found 160 images belonging to 8 classes.
Found 161 images belonging to 8 classes.
Created augmented generator: basic

/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)
/usr/local/lib/python3.11/dist-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.
  self._warn_if_super_not_called()

Epoch 1/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.1323 - loss: 2.2138
Epoch 1: val_accuracy improved from -inf to 0.16875, saving model to model_checkpoints/baseline_basic_best.h5

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 57s 2s/step - accuracy: 0.1324 - loss: 2.2091 - val_accuracy: 0.1688 - val_loss: 1.8824
Epoch 2/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.1250 - loss: 2.0036
Epoch 2: val_accuracy improved from 0.16875 to 0.23125, saving model to model_checkpoints/baseline_basic_best.h5

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 449ms/step - accuracy: 0.1250 - loss: 2.0036 - val_accuracy: 0.2313 - val_loss: 1.8199
Epoch 3/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.2313 - loss: 1.7520
Epoch 3: val_accuracy improved from 0.23125 to 0.25000, saving model to model_checkpoints/baseline_basic_best.h5

def create_improved_model(input_shape, num_classes):
    """
    Improved CNN based on the successful baseline with added batch normalization
    and slight regularization
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), padding='same', input_shape=input_shape),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),

        # Second convolutional block
        layers.Conv2D(64, (3, 3), padding='same'),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),

        # Third convolutional block
        layers.Conv2D(128, (3, 3), padding='same'),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),

        # Fourth convolutional block
        layers.Conv2D(256, (3, 3), padding='same'),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.Dropout(0.3),  # Add dropout only before final layer
        layers.Dense(num_classes, activation='softmax')
    ])

    # Compile the model
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=0.001),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

improved_model = create_improved_model(input_shape=(103,224,3), num_classes=8)
# Train the batch
baseline_history, baseline_test_acc, baseline_y_pred, baseline_y_true = train_model(improved_model, 'improved')

/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Epoch 1/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.6332 - loss: 1.2390
Epoch 1: val_accuracy improved from -inf to 0.12500, saving model to model_checkpoints/improved_best.h5

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 61s 3s/step - accuracy: 0.6400 - loss: 1.2144 - val_accuracy: 0.1250 - val_loss: 6.0096
Epoch 2/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step - accuracy: 1.0000 - loss: 0.0370
Epoch 2: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 424ms/step - accuracy: 1.0000 - loss: 0.0370 - val_accuracy: 0.1250 - val_loss: 6.2834
Epoch 3/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9842 - loss: 0.0745
Epoch 3: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9842 - loss: 0.0743 - val_accuracy: 0.1250 - val_loss: 9.4697
Epoch 4/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 1.0000 - loss: 0.0249
Epoch 4: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 440ms/step - accuracy: 1.0000 - loss: 0.0249 - val_accuracy: 0.1250 - val_loss: 9.5664
Epoch 5/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9923 - loss: 0.0340
Epoch 5: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 48s 2s/step - accuracy: 0.9923 - loss: 0.0341 - val_accuracy: 0.1250 - val_loss: 12.5794
Epoch 6/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.9688 - loss: 0.0308
Epoch 6: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 436ms/step - accuracy: 0.9688 - loss: 0.0308 - val_accuracy: 0.1250 - val_loss: 12.6291
Epoch 7/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9940 - loss: 0.0300
Epoch 7: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 48s 2s/step - accuracy: 0.9941 - loss: 0.0297 - val_accuracy: 0.1250 - val_loss: 14.2568
Epoch 8/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - accuracy: 1.0000 - loss: 0.0115
Epoch 8: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 436ms/step - accuracy: 1.0000 - loss: 0.0115 - val_accuracy: 0.1250 - val_loss: 14.3763
Epoch 9/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9982 - loss: 0.0121
Epoch 9: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 48s 2s/step - accuracy: 0.9982 - loss: 0.0121 - val_accuracy: 0.1250 - val_loss: 15.3026
Epoch 10/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 1.0000 - loss: 0.0039
Epoch 10: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 437ms/step - accuracy: 1.0000 - loss: 0.0039 - val_accuracy: 0.1250 - val_loss: 15.3234
Epoch 11/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9995 - loss: 0.0054
Epoch 11: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 48s 2s/step - accuracy: 0.9995 - loss: 0.0056 - val_accuracy: 0.1250 - val_loss: 15.4392
Epoch 11: early stopping
Restoring model weights from the end of the best epoch: 1.

6/6 ━━━━━━━━━━━━━━━━━━━━ 10s 2s/step - accuracy: 0.2394 - loss: 4.6008
Test accuracy: 0.1242
Test loss: 6.0312

WARNING:tensorflow:5 out of the last 13 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x7e5e2ada05e0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

6/6 ━━━━━━━━━━━━━━━━━━━━ 10s 1s/step

Classification Report:
              precision    recall  f1-score   support

       th_10       0.12      1.00      0.22        20
       th_11       0.00      0.00      0.00        20
       th_12       0.00      0.00      0.00        20
       th_13       0.00      0.00      0.00        20
       th_14       0.00      0.00      0.00        20
       th_15       0.00      0.00      0.00        22
       th_16       0.00      0.00      0.00        18
       th_17       0.00      0.00      0.00        21

    accuracy                           0.12       161
   macro avg       0.02      0.12      0.03       161
weighted avg       0.02      0.12      0.03       161

/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))

def create_regularized_model(input_shape, num_classes):
    """
    Regularized CNN that prevents overfitting on the Clash of Clans dataset
    """
    model = keras.Sequential([
        # First convolutional block
        layers.Conv2D(32, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(0.001), input_shape=input_shape),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.1),  # Light dropout after each block

        # Second convolutional block
        layers.Conv2D(64, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(0.001)),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.1),

        # Third convolutional block
        layers.Conv2D(128, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(0.001)),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.1),

        # Fourth convolutional block
        layers.Conv2D(256, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(0.001)),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Dropout(0.1),

        # Flatten and dense layers
        layers.Flatten(),
        layers.Dense(512, kernel_regularizer=keras.regularizers.l2(0.001)),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.Dropout(0.5),  # Heavy dropout before final classification
        layers.Dense(num_classes, activation='softmax')
    ])

    # Compile the model with a lower learning rate
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=0.0005),  # Reduced learning rate
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

reg_model = create_regularized_model(input_shape=(103,224,3), num_classes=8)
# Train the batch
baseline_history, baseline_test_acc, baseline_y_pred, baseline_y_true = train_model(reg_model, 'regularized')

/usr/local/lib/python3.11/dist-packages/keras/src/layers/convolutional/base_conv.py:107: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Epoch 1/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.5151 - loss: 2.7625
Epoch 1: val_accuracy improved from -inf to 0.12500, saving model to model_checkpoints/regularized_best.h5

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()
WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`.


22/22 ━━━━━━━━━━━━━━━━━━━━ 64s 2s/step - accuracy: 0.5212 - loss: 2.7444 - val_accuracy: 0.1250 - val_loss: 7.3734
Epoch 2/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 12ms/step - accuracy: 0.8438 - loss: 1.8718
Epoch 2: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 445ms/step - accuracy: 0.8438 - loss: 1.8718 - val_accuracy: 0.1250 - val_loss: 7.6905
Epoch 3/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9079 - loss: 1.6603
Epoch 3: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9086 - loss: 1.6590 - val_accuracy: 0.1250 - val_loss: 12.3953
Epoch 4/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 0.9062 - loss: 1.5929
Epoch 4: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 444ms/step - accuracy: 0.9062 - loss: 1.5929 - val_accuracy: 0.1250 - val_loss: 12.6197
Epoch 5/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9621 - loss: 1.4977
Epoch 5: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9621 - loss: 1.4969 - val_accuracy: 0.1250 - val_loss: 16.1690
Epoch 6/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 1.0000 - loss: 1.3963
Epoch 6: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 444ms/step - accuracy: 1.0000 - loss: 1.3963 - val_accuracy: 0.1250 - val_loss: 16.2906
Epoch 7/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9644 - loss: 1.4607
Epoch 7: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9644 - loss: 1.4599 - val_accuracy: 0.1250 - val_loss: 18.8316
Epoch 8/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 10ms/step - accuracy: 1.0000 - loss: 1.3708
Epoch 8: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 444ms/step - accuracy: 1.0000 - loss: 1.3708 - val_accuracy: 0.1250 - val_loss: 18.9336
Epoch 9/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9804 - loss: 1.3939
Epoch 9: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9806 - loss: 1.3929 - val_accuracy: 0.1250 - val_loss: 20.9041
Epoch 10/50
 1/22 ━━━━━━━━━━━━━━━━━━━━ 0s 11ms/step - accuracy: 1.0000 - loss: 1.3040
Epoch 10: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 9s 448ms/step - accuracy: 1.0000 - loss: 1.3040 - val_accuracy: 0.1250 - val_loss: 20.9581
Epoch 11/50
22/22 ━━━━━━━━━━━━━━━━━━━━ 0s 2s/step - accuracy: 0.9969 - loss: 1.3182
Epoch 11: val_accuracy did not improve from 0.12500
22/22 ━━━━━━━━━━━━━━━━━━━━ 49s 2s/step - accuracy: 0.9968 - loss: 1.3178 - val_accuracy: 0.1250 - val_loss: 22.0826
Epoch 11: early stopping
Restoring model weights from the end of the best epoch: 1.

6/6 ━━━━━━━━━━━━━━━━━━━━ 10s 2s/step - accuracy: 0.2394 - loss: 6.4660
Test accuracy: 0.1242
Test loss: 7.3939

WARNING:tensorflow:5 out of the last 13 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x7e5dbc5093a0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

6/6 ━━━━━━━━━━━━━━━━━━━━ 10s 1s/step

Classification Report:
              precision    recall  f1-score   support

       th_10       0.12      1.00      0.22        20
       th_11       0.00      0.00      0.00        20
       th_12       0.00      0.00      0.00        20
       th_13       0.00      0.00      0.00        20
       th_14       0.00      0.00      0.00        20
       th_15       0.00      0.00      0.00        22
       th_16       0.00      0.00      0.00        18
       th_17       0.00      0.00      0.00        21

    accuracy                           0.12       161
   macro avg       0.02      0.12      0.03       161
weighted avg       0.02      0.12      0.03       161

/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))
/usr/local/lib/python3.11/dist-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.
  _warn_prf(average, modifier, f"{metric.capitalize()} is", len(result))

# Check class distribution in train and validation sets
def analyze_data_split(train_ds, val_ds, class_names):
    train_counts = {class_name: 0 for class_name in class_names}
    val_counts = {class_name: 0 for class_name in class_names}

    # Count samples in training set
    for images, labels in train_ds:
        for label in labels:
            label_idx = tf.argmax(label).numpy()
            train_counts[class_names[label_idx]] += 1

    # Count samples in validation set
    for images, labels in val_ds:
        for label in labels:
            label_idx = tf.argmax(label).numpy()
            val_counts[class_names[label_idx]] += 1

    # Print results
    print("Class distribution in training set:")
    for class_name, count in train_counts.items():
        print(f"{class_name}: {count}")

    print("\nClass distribution in validation set:")
    for class_name, count in val_counts.items():
        print(f"{class_name}: {count}")

    return train_counts, val_counts

# Define the transfer learning model
def create_transfer_model(input_shape, num_classes):
    """
    Transfer learning model using MobileNetV2 that respects the dataset's dimensions
    """
    # Create the base model
    base_model = keras.applications.MobileNetV2(
        input_shape=input_shape,
        include_top=False,
        weights='imagenet'
    )

    # Freeze the base model
    base_model.trainable = False

    # Create model with lightweight head
    model = keras.Sequential([
        # Preprocessing layer specifically for MobileNetV2
        keras.layers.Rescaling(1./127.5, offset=-1, input_shape=input_shape),

        # Base model
        base_model,

        # Classification head with regularization
        layers.GlobalAveragePooling2D(),
        layers.Dense(128, activation=None),
        layers.BatchNormalization(),
        layers.Activation('relu'),
        layers.Dropout(0.3),
        layers.Dense(num_classes, activation='softmax')
    ])

    # Compile model with a conservative learning rate
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=0.0005),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# Training function
def train_transfer_model():
    # Create the model
    input_shape = (IMG_HEIGHT, IMG_WIDTH, 3)
    transfer_model = create_transfer_model(input_shape, num_classes)

    # Print model summary
    transfer_model.summary()

    # Define callbacks
    early_stopping = keras.callbacks.EarlyStopping(
        monitor='val_loss',
        patience=5,
        restore_best_weights=True
    )

    # Train the model
    history = transfer_model.fit(
        train_generator,
        steps_per_epoch=steps_per_epoch,
        epochs=30,
        validation_data=validation_generator,
        validation_steps=validation_steps,
        callbacks=[early_stopping]
    )

    # Evaluate the model
    print("\nEvaluating on validation data:")
    val_loss, val_acc = transfer_model.evaluate(validation_generator)
    print(f"Validation accuracy: {val_acc:.4f}")

    print("\nEvaluating on test data:")
    test_loss, test_acc = transfer_model.evaluate(test_generator)
    print(f"Test accuracy: {test_acc:.4f}")

    return transfer_model, history

# Call the function to train and evaluate the transfer learning model
transfer_model, history = train_transfer_model()

<ipython-input-23-725c173cb29d>:7: UserWarning: `input_shape` is undefined or non-square, or `rows` is not in [96, 128, 160, 192, 224]. Weights for input shape (224, 224) will be loaded as the default.
  base_model = keras.applications.MobileNetV2(

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224_no_top.h5
9406464/9406464 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

/usr/local/lib/python3.11/dist-packages/keras/src/layers/preprocessing/tf_data_layer.py:19: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(**kwargs)

Model: "sequential_8"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ rescaling (Rescaling)           │ (None, 103, 224, 3)    │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ mobilenetv2_1.00_224            │ (None, 4, 7, 1280)     │     2,257,984 │
│ (Functional)                    │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ global_average_pooling2d        │ (None, 1280)           │             0 │
│ (GlobalAveragePooling2D)        │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_16 (Dense)                │ (None, 128)            │       163,968 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ batch_normalization_10          │ (None, 128)            │           512 │
│ (BatchNormalization)            │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ activation_10 (Activation)      │ (None, 128)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dropout_6 (Dropout)             │ (None, 128)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_17 (Dense)                │ (None, 8)              │         1,032 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 2,423,496 (9.24 MB)

 Trainable params: 165,256 (645.53 KB)

 Non-trainable params: 2,258,240 (8.61 MB)

Epoch 1/30
22/22 ━━━━━━━━━━━━━━━━━━━━ 74s 3s/step - accuracy: 0.2754 - loss: 1.8546 - val_accuracy: 0.1500 - val_loss: 2.3549
Epoch 2/30

/usr/local/lib/python3.11/dist-packages/keras/src/trainers/epoch_iterator.py:107: UserWarning: Your input ran out of data; interrupting training. Make sure that your dataset or generator can generate at least `steps_per_epoch * epochs` batches. You may need to use the `.repeat()` function when building your dataset.
  self._interrupted_warning()

def visualize_dataset_samples():
    """
    Visualize sample images from training and validation sets to spot potential issues
    """
    # Reset generators to ensure we get fresh batches
    train_generator.reset()
    validation_generator.reset()

    # Get batches
    train_batch = next(train_generator)
    val_batch = next(validation_generator)

    # Extract images and labels
    train_images, train_labels = train_batch
    val_images, val_labels = val_batch

    # Display images
    plt.figure(figsize=(10, 8))

    for i in range(min(4, len(train_images))):
        plt.subplot(2, 4, i+1)
        plt.imshow(train_images[i])
        class_idx = np.argmax(train_labels[i])
        plt.title(f"Train: {class_names[class_idx]}")
        plt.axis('off')

    for i in range(min(4, len(val_images))):
        plt.subplot(2, 4, i+5)
        plt.imshow(val_images[i])
        class_idx = np.argmax(val_labels[i])
        plt.title(f"Val: {class_names[class_idx]}")
        plt.axis('off')

    plt.tight_layout()
    plt.show()

# Run the visualization
visualize_dataset_samples()

# Re-evaluate the baseline model on validation data
def evaluate_baseline():
    # Recreate the baseline model
    input_shape = (IMG_HEIGHT, IMG_WIDTH, 3)
    baseline_model = create_baseline_model(input_shape, num_classes)

    # Load weights if available, or train from scratch if needed
    try:
        baseline_model.load_weights('./model_checkpoints/baseline_best.h5')
        print("Loaded saved baseline model weights")
    except:
        print("No saved weights found, training baseline model from scratch")
        # Define callbacks
        early_stopping = keras.callbacks.EarlyStopping(
            monitor='val_loss',
            patience=5,
            restore_best_weights=True
        )

        # Train the model
        baseline_model.fit(
            train_generator,
            steps_per_epoch=steps_per_epoch,
            epochs=30,
            validation_data=validation_generator,
            validation_steps=validation_steps,
            callbacks=[early_stopping]
        )

    # Evaluate
    print("\nEvaluating baseline on validation data:")
    val_loss, val_acc = baseline_model.evaluate(validation_generator)
    print(f"Validation accuracy: {val_acc:.4f}")

    print("\nEvaluating baseline on test data:")
    test_loss, test_acc = baseline_model.evaluate(test_generator)
    print(f"Test accuracy: {test_acc:.4f}")

    return baseline_model

# Run baseline evaluation
baseline_model = evaluate_baseline()

Loaded saved baseline model weights

Evaluating baseline on validation data:
5/5 ━━━━━━━━━━━━━━━━━━━━ 10s 2s/step - accuracy: 0.9872 - loss: 0.1015
Validation accuracy: 0.9875

Evaluating baseline on test data:
6/6 ━━━━━━━━━━━━━━━━━━━━ 9s 2s/step - accuracy: 0.9872 - loss: 0.0500
Test accuracy: 0.9814

Building a CNN with claude for CNN final deep learning¶

imports and GPU check¶

Environment Setup¶

Dataset Exploration¶

Sample Image Visualization¶

Class distribution analysis¶

Image preprocessing¶

Data Generators Setup¶

Baseline CNN Arch¶

Train Baseline Model¶

CNN Architecture Experiments¶

Data Augmentation Implementation¶

Batch Norm¶

Regularized model¶

Stop and check data says Mr Claude due to massive overfitting with batch norm¶

Transfer Model¶

Claude losing context¶